home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / net / netCode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  28.2 KB  |  1,091 lines
  1. /* 
  2.  * netCode.c --
  3.  *
  4.  *    Various routines for initialzation, input and output.
  5.  *
  6.  *
  7.  * Copyright 1987 Regents of the University of California
  8.  * Permission to use, copy, modify, and distribute this
  9.  * software and its documentation for any purpose and without
  10.  * fee is hereby granted, provided that the above copyright
  11.  * notice appear in all copies.  The University of California
  12.  * makes no representations about the suitability of this
  13.  * software for any purpose.  It is provided "as is" without
  14.  * express or implied warranty.
  15.  */
  16.  
  17. #ifndef lint
  18. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/net/netCode.c,v 9.11 92/06/03 22:47:50 voelker Exp $ SPRITE (Berkeley)";
  19. #endif
  20.  
  21. #include <sprite.h>
  22. #include <list.h>
  23. #include <net.h>
  24. #include <netInt.h>
  25. #include <devNet.h>
  26. #include <string.h>
  27. #include <sync.h>
  28. #include <dbg.h>
  29. #include <machMon.h>
  30. #include <netInet.h>
  31.  
  32. /*
  33.  * Network configuration table defined by machine dependent code.
  34.  */
  35. extern Net_Interface    netConfigInterfaces[];
  36. extern int        netNumConfigInterfaces;
  37. Net_Interface        *netInterfaces[NET_MAX_INTERFACES];
  38. int            netNumInterfaces;
  39.  
  40. Net_Address         netZeroAddress;
  41. int            net_NetworkHeaderSize[NET_NUM_NETWORK_TYPES];
  42.  
  43. #define    INC_BYTES_SENT(gatherPtr, gatherLength) { \
  44.     register    Net_ScatterGather    *gathPtr; \
  45.     int                    i; \
  46.     net_EtherStats.bytesSent += sizeof(Net_EtherHdr); \
  47.     for (i = gatherLength, gathPtr = gatherPtr; i > 0; i--, gathPtr++) { \
  48.         net_EtherStats.bytesSent += gathPtr->length; \
  49.     } \
  50.     }
  51. /*
  52.  * Macro to swap the fragOffset field.
  53.  */
  54. #define SWAP_FRAG_OFFSET_HOST_TO_NET(ptr) { \
  55.     unsigned short    *shortPtr; \
  56.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  57.     *shortPtr = Net_HostToNetShort(*shortPtr); \
  58. } 
  59.  
  60. #define SWAP_FRAG_OFFSET_NET_TO_HOST(ptr) { \
  61.     unsigned short    *shortPtr; \
  62.     shortPtr = ((unsigned short *)&ptr->ident) + 1; \
  63.     *shortPtr = Net_NetToHostShort(*shortPtr); \
  64. } 
  65.  
  66. int netDebug = FALSE;
  67. /* Boolean    ultra = FALSE; */
  68.  
  69. static void NetAddStats _ARGS_((Net_Stats *aPtr, Net_Stats *bPtr, 
  70.             Net_Stats *sumPtr));
  71. static void EnterDebugger _ARGS_((Net_Interface *interPtr, Address packetPtr,
  72.                 int packetLength));
  73.  
  74. /*
  75.  *----------------------------------------------------------------------
  76.  *
  77.  * Net_Init --
  78.  *
  79.  *    Initialize the network module data structures.
  80.  *
  81.  * Results:
  82.  *    None.
  83.  *
  84.  * Side effects:
  85.  *    None.
  86.  *
  87.  *----------------------------------------------------------------------
  88.  */
  89.  
  90. void
  91. Net_Init()
  92. {
  93.     register int i;
  94.     char buffer[100];
  95.     ReturnStatus status;
  96.     int        counter[NET_NUM_NETWORK_TYPES];
  97.     Net_Interface    *interPtr;
  98.     int            j;
  99.  
  100.     NetEtherInit();
  101.  
  102.     for (i = 0; i < NET_NUM_NETWORK_TYPES; i++) {
  103.     counter[i] = 0;
  104.     }
  105.  
  106.     /*
  107.      * Determine the number and kind of network interfaces by calling
  108.      * each network interface initialization procedure.
  109.      */
  110.     bzero((char *) &netZeroAddress, sizeof(Net_Address));
  111.     netNumInterfaces = 0;
  112.     for (i = 0 ; i<netNumConfigInterfaces ; i++) {
  113.     interPtr = &netConfigInterfaces[i];
  114.     interPtr->flags = 0;
  115.     for (j = 0; j < NET_MAX_PROTOCOLS; j++) {
  116.         bzero((char *) &interPtr->netAddress[j], sizeof(Net_Address));
  117.     }
  118.     (void) sprintf(buffer, "NetOutputMutex:%d", i);
  119.     Sync_SemInitDynamic(&interPtr->syncOutputMutex, 
  120.                 strdup(buffer));
  121.     (void) sprintf(buffer, "NetMutex:%d", i);
  122.     Sync_SemInitDynamic(&interPtr->mutex, strdup(buffer));
  123.     status = (interPtr->init)(interPtr);
  124.     if (status == SUCCESS) {
  125.         netInterfaces[netNumInterfaces] = interPtr;
  126.         netNumInterfaces++;
  127.         interPtr->packetProc = NILPROC;
  128.         interPtr->devNetData = (ClientData) NIL;
  129.         interPtr->number = counter[interPtr->netType];
  130.         counter[interPtr->netType]++;
  131.     } 
  132.     }
  133.     net_NetworkHeaderSize[NET_NETWORK_ETHER] = sizeof(Net_EtherHdr);
  134.     net_NetworkHeaderSize[NET_NETWORK_ULTRA] = sizeof(Net_UltraHeader);
  135.     net_NetworkHeaderSize[NET_NETWORK_FDDI] = sizeof(Net_FDDIHdr);
  136.     Net_ArpInit();
  137.     return;
  138. }
  139.  
  140. /*
  141.  *----------------------------------------------------------------------
  142.  *
  143.  * Net_Bin --
  144.  *
  145.  *    Bin various memory sizes allocated by the net module.
  146.  *
  147.  * Results:
  148.  *    None.
  149.  *
  150.  * Side effects:
  151.  *    Calls Mem_Bin to optimize memory allocation.
  152.  *
  153.  *----------------------------------------------------------------------
  154.  */
  155.  
  156. void
  157. Net_Bin()
  158. {
  159.     register int inter;
  160.     for (inter = 0 ; inter < netNumInterfaces ; inter++) {
  161.     Mem_Bin(netInterfaces[inter]->maxBytes);
  162.     }
  163.     return;
  164. }
  165.  
  166. /*
  167.  *----------------------------------------------------------------------
  168.  *
  169.  * Net_GatherCopy --
  170.  *
  171.  *    Copy all of the data pointed to by the scatter/gather array into
  172.  *    the destination.
  173.  *
  174.  * Results:
  175.  *    None.
  176.  *
  177.  * Side effects:
  178.  *    None.
  179.  *
  180.  *----------------------------------------------------------------------
  181.  */
  182.  
  183. void
  184. Net_GatherCopy(scatterGatherPtr, scatterGatherLength, destAddr)
  185.     register    Net_ScatterGather *scatterGatherPtr;
  186.     int                    scatterGatherLength;
  187.     register    Address          destAddr;
  188. {
  189.     int i;
  190.     int soFar = 0;
  191.  
  192.     for (i = 0; i < scatterGatherLength; i++, scatterGatherPtr++) {
  193.     if (scatterGatherPtr->length == 0) {
  194.         continue;
  195.     }
  196.  
  197.     bcopy((Address) scatterGatherPtr->bufAddr, 
  198.          (Address) &(destAddr[soFar]), 
  199.          scatterGatherPtr->length);
  200.     soFar += scatterGatherPtr->length;
  201.     }
  202.     return;
  203. }
  204.  
  205.  
  206.  
  207. /*
  208.  *----------------------------------------------------------------------
  209.  *
  210.  * Net_Reset --
  211.  *
  212.  *    Reset the network interface.
  213.  *
  214.  * Results:
  215.  *    None.
  216.  *
  217.  * Side effects:
  218.  *    Reinitializes the network controller..
  219.  *
  220.  *----------------------------------------------------------------------
  221.  */
  222. void
  223. Net_Reset(interPtr)
  224.     Net_Interface    *interPtr;
  225. {
  226.     interPtr->reset(interPtr);
  227. }
  228.  
  229.  
  230. /*
  231.  *----------------------------------------------------------------------
  232.  *
  233.  * Net_Output --
  234.  *
  235.  *    Send a packet to a host identified by a Sprite Host ID.
  236.  *
  237.  * Results:
  238.  *    SUCCESS     - the operation was successful.
  239.  *    FAILURE        - there was no route to the host or 
  240.  *              the Sprite host ID was bad or 
  241.  *              an unknown route type was found.
  242.  *
  243.  * Side effects:
  244.  *    Sends the packet.
  245.  *    If no route has been established to the SpriteID then the
  246.  *    Address Resolution Protocol (ARP) is invoked to find the
  247.  *    physical address corresponding to the SpriteID.
  248.  *
  249.  *----------------------------------------------------------------------
  250.  */
  251.  
  252. ReturnStatus
  253. Net_Output(spriteID, gatherPtr, gatherLength, mutexPtr, routePtr)
  254.     int spriteID;            /* Host to which to send the packet */
  255.     Net_ScatterGather *gatherPtr;    /* Specifies buffers containing the
  256.                      * pieces of the packet The first
  257.                      * element of gatherPtr is assumed to 
  258.                      * be a buffer large enought to 
  259.                      * format any protocol headers
  260.                      * we need. */
  261.     int gatherLength;            /* Number of elements in gatherPtr[] */
  262.     Sync_Semaphore *mutexPtr;        /* Mutex that is released during the
  263.                      * ARP transaction (if needed).  This
  264.                      * doesn't mess up the caller because
  265.                      * its packet isn't output until
  266.                      * the ARP completes anyway */
  267.     Net_Route    *routePtr;        /* If non-NIL then used as the route
  268.                      * to send the packet. */
  269. {
  270.     Net_Interface    *interPtr;
  271.     Boolean        ourRoute = FALSE;
  272.     ReturnStatus    status;
  273.  
  274.     if (spriteID < 0 || spriteID >= NET_NUM_SPRITE_HOSTS) {
  275.     return(NET_UNREACHABLE_NET);
  276.     }
  277.  
  278.     /*
  279.      * Check for a route to the indicated host.  Use ARP to find it if needed.
  280.      */
  281.     if (routePtr == (Net_Route *) NIL) {
  282.     ourRoute = TRUE;
  283.     routePtr = Net_IDToRoute(spriteID, 0, TRUE, mutexPtr, 0);
  284.     if (routePtr == (Net_Route *)NIL) {
  285.         return(NET_UNREACHABLE_NET);
  286.     }
  287.     }
  288.     interPtr = routePtr->interPtr;
  289.     switch(routePtr->protocol) {
  290.     case NET_PROTO_RAW : {
  291.         /*
  292.          * The first gather buffer contains the protocol header for
  293.          * which we have none for the ethernet.
  294.          */
  295.         gatherPtr->length = 0;     
  296.         gatherPtr->done = FALSE;
  297.         gatherPtr->mutexPtr = mutexPtr;
  298.         status = (interPtr->output) (interPtr, 
  299.             routePtr->headerPtr[NET_PROTO_RAW], 
  300.             gatherPtr, gatherLength, TRUE, &status);
  301.         if (status == SUCCESS) {
  302.             while (!gatherPtr->done && 
  303.             mutexPtr != (Sync_Semaphore *)NIL) {
  304.             (void) Sync_SlowMasterWait((unsigned int)mutexPtr, 
  305.                 mutexPtr, 0);
  306.             }
  307.         }
  308.         break;
  309.         }
  310.     case NET_PROTO_INET: {
  311.         /*
  312.          * For the INET routes we must fill in the ipHeader in the 
  313.          * first buffer of the gather array. 
  314.          */
  315.         register Net_IPHeader        *ipHeaderPtr;
  316.         register unsigned int length;
  317.         register Net_ScatterGather    *gathPtr;
  318.         register int     i; 
  319.  
  320.         /*
  321.          * Compute the length of the gather vector. 
  322.          */
  323.         length = sizeof(Net_IPHeader);
  324.         gathPtr = gatherPtr + 1;
  325.         for (i = 1; i < gatherLength;  i++, gathPtr++){
  326.             length += gathPtr->length; 
  327.         }
  328.  
  329.  
  330.         /*
  331.          * Fill the  ipHeader into the first element of the 
  332.          * scatter/gather from the template stored in the route
  333.          * data.
  334.          */
  335.         gatherPtr->length = sizeof(Net_IPHeader);
  336.         ipHeaderPtr = (Net_IPHeader *) gatherPtr->bufAddr;
  337.         gatherPtr->done = FALSE;
  338.         gatherPtr->mutexPtr = mutexPtr;
  339.  
  340.         *ipHeaderPtr = *(Net_IPHeader *) 
  341.                     routePtr->headerPtr[NET_PROTO_INET];
  342.         /*
  343.          * Update length and checksum. The template 
  344.          * ipHeaderPtr->checksum should contain the 16 bit sum of 
  345.          * the IP header with totalLen set to zero. We add the
  346.          * new total length and convert into one-complement.
  347.          * See Net_InetChecksum().
  348.          */
  349.         length = Net_HostToNetShort(length);
  350.         ipHeaderPtr->totalLen = length;
  351.  
  352.         length = ipHeaderPtr->checksum + length;
  353.         ipHeaderPtr->checksum = ~(length + (length >> 16));
  354.  
  355.         status = (interPtr->output)(interPtr, 
  356.             routePtr->headerPtr[NET_PROTO_RAW], gatherPtr, 
  357.             gatherLength, FALSE, &status);
  358.         if (status == SUCCESS) {
  359.             while (!gatherPtr->done && 
  360.             mutexPtr != (Sync_Semaphore *)NIL) {
  361.             (void) Sync_SlowMasterWait((unsigned int)mutexPtr, 
  362.                     mutexPtr, 0);
  363.             }
  364.         }
  365.         break;
  366.         }
  367.     default:
  368.         printf("Warning: Net_Output: unsupported route protocol: %x\n", 
  369.             routePtr->protocol);
  370.         panic(NIL);
  371.         status = FAILURE;
  372.     }
  373.     if (ourRoute) {
  374.     Net_ReleaseRoute(routePtr);
  375.     }
  376.     return status;
  377. }
  378.  
  379.  
  380.  
  381. /*
  382.  *----------------------------------------------------------------------
  383.  *
  384.  * Net_RawOutput --
  385.  *
  386.  *    Send a packet directly onto the network.
  387.  *
  388.  * Results:
  389.  *    SUCCESS if the packet made it as far as the network interface,
  390.  *    a failure code otherwise.  SUCCESS does not imply that the
  391.  *    packet was actually sent because the interface could have
  392.  *    rejected it.
  393.  *
  394.  * Side effects:
  395.  *    None.
  396.  *
  397.  *----------------------------------------------------------------------
  398.  */
  399.  
  400. ReturnStatus
  401. Net_RawOutput(interPtr, headerPtr, gatherPtr, gatherLength)
  402.     Net_Interface    *interPtr;    /* The network interface. */
  403.     Address        headerPtr;    /* Packet header. */
  404.     Net_ScatterGather    *gatherPtr;    /* Specifies buffers containing the
  405.                      * pieces of the packet */
  406.     int         gatherLength;    /* Number of elements in gatherPtr[] */
  407. {
  408.     return (interPtr->output)(interPtr, headerPtr, gatherPtr, gatherLength, 
  409.         FALSE, (ReturnStatus *) NIL);
  410. }
  411.  
  412.  
  413. /*
  414.  *----------------------------------------------------------------------
  415.  *
  416.  * Net_RecvPoll --
  417.  *
  418.  *    See if a packet has come in.  If one has come in then it is assumed
  419.  *    that the packet processing routine will get called.  Thus this routine
  420.  *    does not return any value; it is up to the packet processing routine
  421.  *    to set some global state.  This is intended to be used by the
  422.  *    debugger.
  423.  *
  424.  * Results:
  425.  *    None.
  426.  *
  427.  * Side effects:
  428.  *    None.
  429.  *
  430.  *----------------------------------------------------------------------
  431.  */
  432.  
  433. void
  434. Net_RecvPoll(interPtr)
  435.     Net_Interface    *interPtr;    /* Network interface. */
  436. {
  437.     if (netDebug) {
  438.     printf("Net_RecvPoll\n");
  439.     }
  440.     (interPtr->intr)(interPtr, TRUE);
  441. }
  442.  
  443.  
  444. /*
  445.  *----------------------------------------------------------------------
  446.  *
  447.  * Net_RawOutputSync --
  448.  *
  449.  *     Send a packet on the network. Does not return until the packet
  450.  *    is actually sent.
  451.  *
  452.  * Results:
  453.  *    SUCCESS if the packet was sent correctly, otherwise a standard
  454.  *    Sprite return status.
  455.  *
  456.  * Side effects:
  457.  *    None.
  458.  *
  459.  *----------------------------------------------------------------------
  460.  */
  461. ReturnStatus
  462. Net_RawOutputSync(interPtr, headerPtr, gatherPtr, gatherLength)
  463.     Net_Interface    *interPtr;    /* Network interface. */
  464.     Address        headerPtr;    /* Packet header. */
  465.     Net_ScatterGather     *gatherPtr;    /* Specifies buffers containing the
  466.                      * pieces of the packet */
  467.     int         gatherLength;    /* Number of elements in gatherPtr[] */
  468. {
  469.     ReturnStatus    status;
  470.  
  471.     gatherPtr->mutexPtr = &(interPtr->syncOutputMutex);
  472.     gatherPtr->done = FALSE;
  473.  
  474.     MASTER_LOCK(&(interPtr->syncOutputMutex));
  475.  
  476.     status = (interPtr->output)(interPtr, headerPtr, gatherPtr, gatherLength, 
  477.     FALSE, &status);
  478.     if (status == SUCCESS) {
  479.     while (!gatherPtr->done) {
  480.         (void) Sync_SlowMasterWait(
  481.             (unsigned int)&(interPtr->syncOutputMutex), 
  482.             &(interPtr->syncOutputMutex), FALSE);
  483.     }
  484.     }
  485.     MASTER_UNLOCK(&(interPtr->syncOutputMutex));
  486.     return status;
  487. }
  488.  
  489. /*
  490.  *----------------------------------------------------------------------
  491.  *
  492.  * NetOutputWakeup --
  493.  *
  494.  *    Called to notify a waiter that a packet has been sent.  This is
  495.  *    hacked up now, as the argument is really a mutexPtr which
  496.  *    has been used as a raw event to wait on.  We have to use
  497.  *    the raw SlowBroadcast procedure because of this.
  498.  *
  499.  * Results:
  500.  *    None.
  501.  *
  502.  * Side effects:
  503.  *    None.
  504.  *
  505.  *----------------------------------------------------------------------
  506.  */
  507.  
  508. void
  509. NetOutputWakeup(mutexPtr)
  510.     Sync_Semaphore    *mutexPtr;    /* Mutex from scatter/gather struct */
  511. {
  512.     int waiting;
  513.  
  514.     /*
  515.      * FIX THIS.
  516.      */
  517.     if (dbg_UsingNetwork) {
  518.     return;
  519.     }
  520.  
  521. #if (MACH_MAX_NUM_PROCESSORS == 1) /* uniprocessor implementation */
  522.     (void) Sync_SlowBroadcast((unsigned int)mutexPtr, &waiting);
  523. #else     /* Mutiprocessor implementation */
  524.    /*
  525.     * Because the packet sent interrupt may come in before Net_Output
  526.     * has a chance to MasterWait and after Net_Output has checked the
  527.     * gatherPtr->done flag, the code should syncronize with the caller
  528.     * by obtaining the master lock.
  529.     */
  530.     MASTER_LOCK(mutexPtr);
  531.     (void) Sync_SlowBroadcast((unsigned int) mutexPtr, &waiting);    
  532.     MASTER_UNLOCK(mutexPtr);
  533. #endif
  534.     return;
  535. }
  536.  
  537.  
  538. /*
  539.  *----------------------------------------------------------------------
  540.  *
  541.  * Net_Intr --
  542.  *
  543.  *    The interrupt routine which is called when the ethernet chip 
  544.  *    interrupts the processor.  All this routine does is to branch
  545.  *    to the interrupt handler for the type of ethernet device
  546.  *    present on the machine.  The device driver, in turn, eventually
  547.  *    calls Net_Input to pass the packet to the correct protocol handler.
  548.  *
  549.  * Results:
  550.  *    None.
  551.  *
  552.  * Side effects:
  553.  *    None.
  554.  *
  555.  *----------------------------------------------------------------------
  556.  */
  557.  
  558. int
  559. Net_Intr(interPtr)
  560.     Net_Interface    *interPtr;    /* Network interface. */
  561. {
  562.     if (netDebug) {
  563.     printf("Received an interrupt on interface %s\n", interPtr->name);
  564.     }
  565.     (interPtr->intr)(interPtr, FALSE);
  566.     return 1;
  567. }
  568.  
  569. /*
  570.  *----------------------------------------------------------------------
  571.  *
  572.  * Net_Input --
  573.  *
  574.  *    A stub called by device drivers to pass off packets to protocols.
  575.  *    This could be a macro.
  576.  *
  577.  *    The packet handler called must copy the packet to private buffers.
  578.  *
  579.  *    TODO:
  580.  *        This routine, and the ones it calls, should not assume
  581.  *        that there is a packet header at the start of the
  582.  *        packet.  The header should be passed separately.
  583.  *
  584.  * Results:
  585.  *    None.
  586.  *
  587.  * Side effects:
  588.  *    None.  
  589.  *
  590.  *----------------------------------------------------------------------
  591.  */
  592.  
  593. void
  594. Net_Input(interPtr, packetPtr, packetLength)
  595.     Net_Interface *interPtr;    /* Network interface. */
  596.     Address packetPtr;        /* The packet. */
  597.     int packetLength;        /* The length of the packet. */
  598. {
  599.     int        headerSize;
  600.     int        packetType = NET_PACKET_UNKNOWN;
  601.  
  602. #if 0
  603.     printf("in Net_Input\n");
  604.     printf("Net_Input(0x%x, 0x%x, 0x%x)\n", interPtr, packetPtr, packetLength);
  605.     printf("netType = %08x\n", interPtr->netType);
  606. #endif
  607.  
  608.     if (netDebug) {
  609.     printf("Net_Input(0x%x, 0x%x, 0x%x) netType = %08x\n",
  610.         interPtr, packetPtr, packetLength, interPtr->netType);
  611.     }
  612.     switch(interPtr->netType) {
  613.     case NET_NETWORK_ETHER : {
  614.         Net_EtherHdr *etherHdrPtr;
  615.         int        type;
  616.         etherHdrPtr = (Net_EtherHdr *)packetPtr;
  617.         type = Net_NetToHostShort((unsigned short)
  618.             NET_ETHER_HDR_TYPE(*etherHdrPtr));
  619.         switch(type) {
  620.         case NET_ETHER_SPRITE:
  621.             packetType = NET_PACKET_SPRITE;
  622.             break;
  623.         case NET_ETHER_ARP:
  624.             packetType = NET_PACKET_ARP;
  625.             break;
  626.         case NET_ETHER_REVARP:
  627.             packetType = NET_PACKET_RARP;
  628.             break;
  629.         case NET_ETHER_SPRITE_DEBUG:
  630.             packetType = NET_PACKET_DEBUG;
  631.             break;
  632.         case NET_ETHER_IP:
  633.             packetType = NET_PACKET_IP;
  634.             break;
  635.         default:
  636.             packetType = NET_PACKET_UNKNOWN;
  637.             break;
  638.         }
  639.         break;
  640.     }
  641.     case NET_NETWORK_ULTRA: {
  642.         Net_UltraHeader    *ultraHdrPtr;
  643.         ultraHdrPtr = (Net_UltraHeader *) packetPtr;
  644.         if ((ultraHdrPtr->localAddress.tsapSize == 2) &&
  645.         (ultraHdrPtr->localAddress.tsap[0] == (unsigned char) 0xff) &&
  646.         (ultraHdrPtr->localAddress.tsap[1] == (unsigned char) 0xff)) {
  647.         packetType = NET_PACKET_SPRITE;
  648.         } else {
  649.         packetType = NET_PACKET_UNKNOWN;
  650.         }
  651.         break;
  652.     }
  653.     case NET_NETWORK_FDDI: {     /***/
  654.         Net_FDDIHdr *fddiHdrPtr;
  655.  
  656.         fddiHdrPtr = (Net_FDDIHdr *)packetPtr;
  657.         if (fddiHdrPtr->frameControl == NET_FDDI_SPRITE) {
  658.         packetType = NET_PACKET_SPRITE;
  659.         } else {
  660.         packetType = NET_PACKET_UNKNOWN;
  661.         }
  662.         break;
  663.     }
  664.     default: 
  665.         printf("Net_Input: invalid net type %d\n", interPtr->netType);
  666.     }
  667.     headerSize = net_NetworkHeaderSize[interPtr->netType];
  668.     if (dbg_UsingNetwork) {
  669.     /*
  670.      * If the kernel debugger is running it gets all the packets. We
  671.      * process ARP requests to allow hosts to talk to the debugger.
  672.      */
  673.     if (packetType == NET_PACKET_ARP) {
  674.             NetArpInput(interPtr, packetPtr, packetLength);
  675.     } else { 
  676.         Dbg_InputPacket(interPtr, packetPtr, packetLength);
  677.     }
  678.     return;
  679.     }
  680.     switch(packetType) {
  681.         case NET_PACKET_SPRITE:
  682.         if (netDebug) {
  683.         printf("Received a Sprite packet, calling Rpc_Dispatch\n");
  684.         }
  685.             Rpc_Dispatch(interPtr, NET_PROTO_RAW, packetPtr, 
  686.              (Address) (((char *) packetPtr) + headerSize), 
  687.              packetLength - headerSize);
  688.             break;
  689.  
  690.         case NET_PACKET_ARP:
  691.     case NET_PACKET_RARP:
  692.         /*
  693.          * The kernel gets first shot at ARP packets and then they are
  694.          * forward to tbe /dev/net device.
  695.          */
  696.         if (netDebug) {
  697.         if (packetType == NET_PACKET_ARP) {
  698.             printf("Received an ARP packet.\n");
  699.         } else {
  700.             printf("Received a RARP packet.\n");
  701.         }
  702.         }
  703.             NetArpInput(interPtr, packetPtr, packetLength);
  704.         if (interPtr->packetProc != NILPROC) {
  705.         (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  706.         }
  707.         break;
  708.  
  709.         case NET_PACKET_DEBUG:
  710.         if (netDebug) {
  711.         printf("Received a debug packet.\n");
  712.         }
  713.             EnterDebugger(interPtr, packetPtr, packetLength);
  714.             break;
  715.  
  716.     case NET_PACKET_IP: {
  717.         register Net_IPHeader *ipHeaderPtr = 
  718.             (Net_IPHeader *) (packetPtr + headerSize);
  719.         /*
  720.          * The kernel steals IP packets with the Sprite RPC protocol number.
  721.          */
  722.         if (netDebug) {
  723.         printf("Received an IP packet.\n");
  724.         }
  725.         if ( (packetLength > sizeof(Net_IPHeader)+headerSize) && 
  726.              (ipHeaderPtr->protocol == NET_IP_PROTOCOL_SPRITE)) {
  727.         int    headerLenInBytes;
  728.         int    totalLenInBytes;
  729.         headerLenInBytes = ipHeaderPtr->headerLen * 4;
  730.         totalLenInBytes = Net_NetToHostShort(ipHeaderPtr->totalLen);
  731.         /*
  732.          * Validate the packet. We toss out the following cases:
  733.          * 1) Runt packets.
  734.          * 2) Bad checksums.
  735.          * 3) Fragments.
  736.          * Since we sent the packets with dont fragment set we 
  737.          * shouldn't get any fragments.
  738.          */
  739.         if ((headerLenInBytes >= sizeof(Net_IPHeader)) &&
  740.              (totalLenInBytes > headerLenInBytes) &&
  741.              (totalLenInBytes <= (packetLength-headerSize)) &&
  742.              (Net_InetChecksum(headerLenInBytes, (Address)ipHeaderPtr)
  743.                                 == 0)) {
  744.  
  745.             SWAP_FRAG_OFFSET_NET_TO_HOST(ipHeaderPtr);
  746.             if((!(ipHeaderPtr->flags & NET_IP_MORE_FRAGS)) &&
  747.               (ipHeaderPtr->fragOffset == 0)) {
  748.             if (netDebug) {
  749.                 printf(
  750.             "Received a Sprite IP packet, calling Rpc_Dispatch\n");
  751.             }
  752.             Rpc_Dispatch(interPtr, NET_PROTO_INET, packetPtr, 
  753.                    (Address)(((char *) ipHeaderPtr) + headerLenInBytes),
  754.                      totalLenInBytes-headerLenInBytes);
  755.              }
  756.         }
  757.  
  758.         } else {
  759.  
  760.         if (interPtr->packetProc != NILPROC) {
  761.             (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  762.         }
  763.         }
  764.         break;
  765.     }
  766.     default:
  767.         if (netDebug) {
  768.         printf("Received a packet with unknown type 0x%x.\n",
  769.             packetType);
  770.         }
  771.         if (interPtr->packetProc != NILPROC) {
  772.         (interPtr->packetProc)(interPtr, packetLength, packetPtr);
  773.         }
  774.         break;
  775.     }
  776.     return;
  777. }
  778.  
  779.  
  780. /*
  781.  *----------------------------------------------------------------------
  782.  *
  783.  * EnterDebugger --
  784.  *
  785.  *    Processes the special NET_ETHER_SPRITE_DEBUG packet type.
  786.  *    Prints the data in the packet (which is the hostname of the sender)
  787.  *    and then enters the debugger. The format of data in the packet is:
  788.  *     1) size of sender's name in bytes (4 bytes),
  789.  *     2) the sender's name (max 100 bytes).
  790.  *
  791.  * Results:
  792.  *    None.
  793.  *
  794.  * Side effects:
  795.  *    Enters the debugger.
  796.  *
  797.  *----------------------------------------------------------------------
  798.  */
  799.  
  800. /* ARGSUSED */
  801. static void
  802. EnterDebugger(interPtr, packetPtr, packetLength)
  803.     Net_Interface    *interPtr;
  804.     Address packetPtr;
  805.     int packetLength;
  806. {
  807.     char *name;
  808.     unsigned int  len;
  809.  
  810.     packetPtr += net_NetworkHeaderSize[interPtr->netType];
  811.     /*
  812.      * Copy the length out of the packet into a correctly aligned integer.
  813.      * Correct its byte order.
  814.      */
  815.     bcopy( packetPtr, (Address) &len, sizeof(len));
  816.  
  817.     len = Net_NetToHostInt(len);
  818.  
  819.     /*
  820.      * Validate the data length and make sure the name is null-terminated.
  821.      */
  822.     if (len < 100) {
  823.     name = (char *) (packetPtr + sizeof(len));
  824.     name[len] = '\0';
  825.     printf("\n*** Got a debugger packet from %s ***\n", name);
  826.     } else {
  827.     printf("\n*** Got a debugger packet ***\n");
  828.     }
  829.  
  830.     DBG_CALL;
  831.     return;
  832. }
  833.  
  834. /*
  835.  *----------------------------------------------------------------------
  836.  *
  837.  * Net_GetInterface --
  838.  *
  839.  *    Returns a pointer to the interface structure with the
  840.  *    given number and type.
  841.  *
  842.  * Results:
  843.  *    A pointer to a Net_Interface if one with the given number
  844.  *    exists, NIL otherwise.
  845.  *
  846.  * Side effects:
  847.  *    None.
  848.  *
  849.  *----------------------------------------------------------------------
  850.  */
  851.  
  852. Net_Interface *
  853. Net_GetInterface(netType, number)
  854.     Net_NetworkType    netType;    /* Type of interface. */
  855.     int            number;        /* Number of interface. */
  856. {
  857.     Net_Interface    *interPtr;
  858.     register int    i;
  859.  
  860.     interPtr = (Net_Interface *) NIL;
  861.     for (i = 0; i < netNumInterfaces; i++) {
  862.     if (netInterfaces[i]->netType == netType &&
  863.         netInterfaces[i]->number == number) {
  864.         interPtr = netInterfaces[i];
  865.         break;
  866.     }
  867.     }
  868.     return interPtr;
  869. }
  870. /*
  871.  *----------------------------------------------------------------------
  872.  *
  873.  * Net_GetInterfaceByAddr --
  874.  *
  875.  *    Returns a pointer to the interface whose address matches the 
  876.  *     given address. If the address is an IP address then the IP
  877.  *    address for the interface had better be set.
  878.  *
  879.  * Results:
  880.  *    A pointer to the desired Net_Interface if one is found, NIL
  881.  *    otherwise.
  882.  *
  883.  * Side effects:
  884.  *    None.
  885.  *
  886.  *----------------------------------------------------------------------
  887.  */
  888.  
  889. Net_Interface *
  890. Net_GetInterfaceByAddr(netAddressPtr)
  891.     Net_Address        *netAddressPtr;    /* Address to use. */
  892. {
  893.     register int    i, j;
  894.  
  895.     for (i = 0; i < netNumInterfaces; i++) {
  896.     for (j = 0; j < NET_MAX_PROTOCOLS; j++) {
  897.         if (!Net_AddrCmp(netAddressPtr, &netInterfaces[i]->netAddress[j])) {
  898.         return netInterfaces[i];
  899.         }
  900.     }
  901.     }
  902.     return (Net_Interface *) NIL;
  903. }
  904.  
  905. /*
  906.  *----------------------------------------------------------------------
  907.  *
  908.  * Net_NextInterface --
  909.  *
  910.  *     This routine can be used to iterate through all network
  911.  *    interfaces, regardless of type.  The parameter 'index'
  912.  *    is used to keep track of where we are in the interaction.
  913.  *    A pointer will be returned to first interface whose index
  914.  *    is equal to or greater than 'index' and that is running.
  915.  *    The 'index' parameter will be set to the index of the
  916.  *    interface upon return.  
  917.  *
  918.  * Results:
  919.  *    A pointer to the first interface whose number if greater than
  920.  *    or equal to the contents of indexPtr and is running. NIL
  921.  *    if no such interface exists.
  922.  *
  923.  * Side effects:
  924.  *    None.
  925.  *
  926.  *----------------------------------------------------------------------
  927.  */
  928.  
  929. Net_Interface *
  930. Net_NextInterface(running, indexPtr)
  931.     Boolean        running;    /* TRUE => returned interface    
  932.                      * must be in running state. */
  933.     int            *indexPtr;    /* Ptr to index to use. */
  934. {
  935.     register int    i;
  936.  
  937.     for (i = *indexPtr; i < netNumInterfaces; i++) {
  938.     if (netDebug) {
  939.         printf("i = %d, name = %s, running = %d\n", i, 
  940.         netInterfaces[i]->name, 
  941.         netInterfaces[i]->flags & NET_IFLAGS_RUNNING);
  942.     }
  943.     if (!running || netInterfaces[i]->flags & NET_IFLAGS_RUNNING) {
  944.         *indexPtr = i;
  945.         return netInterfaces[i];
  946.     }
  947.     }
  948.     return (Net_Interface *) NIL;
  949. }
  950.  
  951. /*
  952.  *----------------------------------------------------------------------
  953.  *
  954.  * Net_SetPacketHandler --
  955.  *
  956.  *    Routine to register a callback for each packet received
  957.  *    on a particular network interface.
  958.  *    Right now the Net_Input routine knows about the different
  959.  *     types of packets and knows which routines to call.  This
  960.  *    routine is used to set the callback for generic packets
  961.  *    so that the dev module sees them. 
  962.  *
  963.  *    The handler parameter should have the following definition:
  964.  *        void    handler(interPtr, packetPtr, size)
  965.  *            Net_Interface    *interPtr; 
  966.  *            Address        packetPtr; 
  967.  *            int        size;       
  968.  *
  969.  *    TODO:  It would probably be nice to classify packets (rpc, ip,
  970.  *        ether, etc) and register interest in the different
  971.  *        classifications. That would make Net_Input more
  972.  *        general.
  973.  *
  974.  * Results:
  975.  *    None.
  976.  *
  977.  * Side effects:
  978.  *    The function parameter will be called for all 'normal' network
  979.  *    packets.
  980.  *
  981.  *----------------------------------------------------------------------
  982.  */
  983.  
  984. void
  985. Net_SetPacketHandler(interPtr, handler)
  986.     Net_Interface    *interPtr;    /* The interface. */
  987.     void        (*handler)();    /* Packet handling routine. */
  988. {
  989.     interPtr->packetProc = handler;
  990. }
  991.  
  992. /*
  993.  *----------------------------------------------------------------------
  994.  *
  995.  * Net_RemovePacketHandler --
  996.  *
  997.  *    Routine to remove a packet handler callback procedure.
  998.  *
  999.  * Results:
  1000.  *    None.
  1001.  *
  1002.  * Side effects:
  1003.  *    None.
  1004.  *
  1005.  *----------------------------------------------------------------------
  1006.  */
  1007.  
  1008. void
  1009. Net_RemovePacketHandler(interPtr)
  1010.     Net_Interface    *interPtr;    /* The interface. */
  1011. {
  1012.     interPtr->packetProc = NILPROC;
  1013. }
  1014.  
  1015. /*
  1016.  *----------------------------------------------------------------------
  1017.  *
  1018.  * Net_GetStats --
  1019.  *
  1020.  *    Returns the event statistics for the various network 
  1021.  *    interfaces.  The sum of the stats for all interfaces of the
  1022.  *    given type is returned.
  1023.  *
  1024.  * Results:
  1025.  *    SUCCESS if the statistics are returned, an error code otherwise
  1026.  *
  1027.  * Side effects:
  1028.  *    None.
  1029.  *
  1030.  *----------------------------------------------------------------------
  1031.  */
  1032.  
  1033. ReturnStatus
  1034. Net_GetStats(netType, statPtr)
  1035.     Net_NetworkType    netType;     /* Type of interfaces to get stats
  1036.                      * for. */
  1037.     Net_Stats        *statPtr;    /* Statistics to fill in. */ 
  1038. {
  1039.     int            i;
  1040.     ReturnStatus    status = SUCCESS;
  1041.     Net_Stats        tmpStats;
  1042.  
  1043.     bzero((char *) statPtr, sizeof(Net_Stats));
  1044.     for (i = 0; i < netNumInterfaces; i++) {
  1045.     if ((netInterfaces[i]->flags & NET_IFLAGS_RUNNING) &&
  1046.         (netInterfaces[i]->netType == netType)) {
  1047.         status = (netInterfaces[i]->getStats)(netInterfaces[i], &tmpStats);
  1048.         if (status != SUCCESS) {
  1049.         break;
  1050.         }
  1051.         NetAddStats(&tmpStats, statPtr, statPtr);
  1052.     }
  1053.     }
  1054.     return status;
  1055. }
  1056.  
  1057.  
  1058. /*
  1059.  *----------------------------------------------------------------------
  1060.  *
  1061.  * NetAddStats --
  1062.  *
  1063.  *    Add two stats structures together. This routine assumes that
  1064.  *    the structures are composed of only integers.
  1065.  *
  1066.  * Results:
  1067.  *    None.
  1068.  *
  1069.  * Side effects:
  1070.  *    None.
  1071.  *
  1072.  *----------------------------------------------------------------------
  1073.  */
  1074.  
  1075. static void
  1076. NetAddStats(aPtr, bPtr, sumPtr)
  1077.     Net_Stats *aPtr;            /* First addend. */
  1078.     Net_Stats *bPtr;            /* Second addend. */
  1079.     Net_Stats *sumPtr;            /* The sum of the two. */
  1080. {
  1081.     Net_Stats        tmp;
  1082.     int            i;
  1083.  
  1084.     bzero((char *) &tmp, sizeof(tmp));
  1085.     for (i = 0; i < sizeof(Net_Stats) / sizeof(int); i++) {
  1086.     ((int *) &tmp)[i] = ((int *) aPtr)[i] + ((int *) bPtr)[i];
  1087.     }
  1088.     bcopy((char *) &tmp, (char *) sumPtr, sizeof(Net_Stats));
  1089. }
  1090.  
  1091.